import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;

/**
 * <p>
 * Materialien zu den zentralen NRW-Abiturpruefungen im Fach Informatik ab 2018
 * </p>
 * <p>
 * Klasse Client
 * </p>
 * <p>
 * Objekte von Unterklassen der abstrakten Klasse Client ermoeglichen
 * Netzwerkverbindungen zu einem Server mittels TCP/IP-Protokoll. Nach
 * Verbindungsaufbau koennen Zeichenketten (Strings) zum Server gesendet und von
 * diesem empfangen werden, wobei der Nachrichtenempfang nebenlaeufig geschieht. 
 * Zur Vereinfachung finden Nachrichtenversand und -empfang zeilenweise statt,
 * d. h., beim Senden einer Zeichenkette wird ein Zeilentrenner ergaenzt und beim
 * Empfang wird dieser entfernt. Jede empfangene Nachricht wird einer
 * Ereignisbehandlungsmethode uebergeben, die in Unterklassen implementiert werden
 * muss. Es findet nur eine rudimentaere Fehlerbehandlung statt, so dass z.B.
 * Verbindungsabbrueche nicht zu einem Programmabbruch fuehren. Eine einmal
 * unterbrochene oder getrennte Verbindung kann nicht reaktiviert werden.
 * </p>
 * 
 * @author Qualitaets- und UnterstuetzungsAgentur - Landesinstitut fuer Schule
 * @version 30.08.2016
 */

public abstract class Client{
  private MessageHandler messageHandler;

  private class MessageHandler extends Thread{
    private SocketWrapper socketWrapper;
    private boolean active;

    private class SocketWrapper{
      private Socket socket;
      private BufferedReader fromServer;
      private PrintWriter toServer;

      public SocketWrapper(String pServerIP, int pServerPort){
        try{
          socket = new Socket(pServerIP, pServerPort);
          toServer = new PrintWriter(socket.getOutputStream(), true);
          fromServer = new BufferedReader(new InputStreamReader(socket.getInputStream()));
        } catch (IOException e){
          socket = null;
          toServer = null;
          fromServer = null;
        }
      }

      public String receive(){
        if(fromServer != null)
          try{
            return fromServer.readLine();
          } catch (IOException e){}
        return(null);
      }

      public void send(String pMessage){
        if(toServer != null){
          toServer.println(pMessage);
        }
      }

      public void close(){
        if(socket != null)
          try{
            socket.close();
          } catch (IOException e) {
            /*
             * Falls eine Verbindung getrennt werden soll, deren Endpunkt
             * nicht mehr existiert bzw. ihrerseits bereits beendet worden ist,
             * geschieht nichts.
             */
          }
      }
    }

    private MessageHandler(String pServerIP, int pServerPort) {
      socketWrapper = new SocketWrapper(pServerIP, pServerPort);
      start();
      if(socketWrapper.socket != null)
        active = true;
    }

    public void run(){
      String message = null;
      while (active){
        message = socketWrapper.receive();
        if (message != null)
          processMessage(message);
        else
          close();
      }
    }

    private void send(String pMessage){
      if(active)
        socketWrapper.send(pMessage);
    }

    private void close(){
      if(active){
        active = false;
        socketWrapper.close();
      }
    }
  }

  public Client(String pServerIP, int pServerPort){
    messageHandler = new MessageHandler(pServerIP, pServerPort);
  }

  public boolean isConnected(){
    return(messageHandler.active);
  }

  public void send(String pMessage){
    messageHandler.send(pMessage);
  }

  public void close() {
    messageHandler.close();
  }

  public abstract void processMessage(String pMessage);

}